package mysql

import (
	"data-transfer/domain"
	"data-transfer/global"
	"go.uber.org/zap"
	"golang.org/x/net/context"
	"strconv"
)

// HasBizData 判断是否已经有业务主键的数据,如果是true,则不进行业务数据插入操作
func (mdb *db) HasBizData(tableName string, condition ...string) (bool, error) {
	if len(condition) == 0 {
		global.LOG.Error("根据业务主键查询数据时，请输入查询条件！")
		return true, nil
	}
	switch tableName {
	case "BALANCE_SHEET": // 一般企业资产负债表(新准则产品表)
		compCode := condition[0]
		reportYear := condition[1]
		reportDateType := condition[2]

		obj := new(domain.BALANCE_SHEET)
		obj.Compcode = compCode
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "INCOME_STATEMENT": //一般企业利润表(新准则产品表)
		compCode := condition[0]
		reportYear := condition[1]
		reportDateType := condition[2]

		obj := new(domain.INCOME_STATEMENT)
		obj.Compcode = compCode
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "CASH_FLOW":
		compCode := condition[0]
		reportYear := condition[1]
		reportDateType := condition[2]

		obj := new(domain.CASH_FLOW)
		obj.Compcode = compCode
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "KEY_INDICATOR": // 财务主要指标

		compCode := condition[0]
		reportYear := condition[1]
		reportDateType := condition[2]

		obj := new(domain.KEY_INDICATOR)
		obj.Compcode = compCode
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "KEY_INDICATOR_SQ": // 主要指标单季度
		compCode := condition[0]
		reportYear := condition[1]
		reportDateType := condition[2]

		obj := new(domain.KEY_INDICATOR_SQ)
		obj.Compcode = compCode
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "CASH_FLOW_SQ": // 现金流 单季度
		compCode := condition[0]
		reportYear := condition[1]
		reportDateType := condition[2]

		obj := new(domain.CASH_FLOW_SQ)
		obj.Compcode = compCode
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "LATEST_INDICATOR": // 最新指标
		compCode := condition[0]
		symbol := condition[1]
		exchange := condition[2]
		reportYear := condition[3]
		reportDateType := condition[4]

		obj := new(domain.LATEST_INDICATOR)
		obj.Compcode = compCode
		obj.Symbol = symbol
		obj.Exchange = exchange
		obj.Reportyear = reportYear
		obj.Reportdatetype = reportDateType

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "EVENT_REMIND": // 大事提醒
		//按照约定顺序接收业务主键参数
		compCode := condition[0]
		declareDate := condition[1]
		eventTitle := condition[2]
		rankStr := condition[3]
		rank, _ := strconv.Atoi(rankStr)
		obj := new(domain.EVENT_REMIND)
		obj.Compcode = compCode
		obj.Declaredate = declareDate
		obj.Eventtitle = eventTitle
		obj.Rank = rank
		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "DIVIDEND": // 分红派送
		compCode := condition[0]
		exrightdate := condition[1]
		bonusyear := condition[2]
		dividtype := condition[3]
		divitype := condition[4]

		obj := new(domain.DIVIDEND)
		obj.Compcode = compCode
		obj.Exrightdate = exrightdate
		obj.Bonusyear = bonusyear
		obj.Dividtype = dividtype
		obj.Divitype = divitype

		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "BONUS_FINANCING": //分红融资
		compCode := condition[0]
		bonusYear := condition[1]
		dividtype := condition[2]
		divitype := condition[3]
		exrightDate := condition[4]

		obj := new(domain.BONUS_FINANCING)
		obj.Compcode = compCode
		obj.Bonusyear = bonusYear
		obj.Dividtype = dividtype
		obj.Divitype = divitype
		obj.Exrightdate = exrightDate

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "MARGIN": //融资融券
		symbol := condition[0]
		tradeDate := condition[1]

		obj := new(domain.MARGIN)
		obj.Symbol = symbol
		obj.Tradedate = tradeDate

		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "PROFIT_FORECAST": //盈利预测
		compCode := condition[0]
		symbol := condition[1]
		publishDate := condition[2]
		exptYear := condition[3]

		obj := new(domain.PROFIT_FORECAST)
		obj.Compcode = compCode
		obj.Symbol = symbol
		obj.Publishdate = publishDate
		obj.Exptyear = exptYear

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "RATING_COUNT": //机构评级统计信息
		symbol := condition[0]
		ratingValid := condition[1]

		obj := new(domain.RATING_COUNT)
		obj.Symbol = symbol
		obj.Ratingvalid = ratingValid

		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "RATING": //机构评级信息
		skCode := condition[0]
		reportDate := condition[1]
		ratingValid := condition[2]
		analystName := condition[3]

		obj := new(domain.RATING)
		obj.Skcode = skCode
		obj.Reportdate = reportDate
		obj.Ratingvalid = ratingValid
		obj.Analystname = analystName

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "COMPANY_PROFILE": //公司基本情况
		compCode := condition[0]
		symbol := condition[1]
		exchange := condition[2]

		obj := new(domain.COMPANY_PROFILE)
		obj.Compcode = compCode
		obj.Symbol = symbol
		obj.Exchange = exchange

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "MAIN_COMPOSITION": // 公司主要业务
		compCode := condition[0]
		publishDate := condition[1]
		typeStyle := condition[2]

		obj := new(domain.MAIN_COMPOSITION)
		obj.Compcode = compCode
		obj.Publishdate = publishDate
		obj.Typestyle = typeStyle

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "COMPANY_EXECUTIVES": //公司高管
		compCode := condition[0]
		personalCode := condition[1]
		actdutyName := condition[2]
		beginDate := condition[3]

		obj := new(domain.COMPANY_EXECUTIVES)
		obj.Compcode = compCode
		obj.Personalcode = personalCode
		obj.Actdutyname = actdutyName
		obj.Begindate = beginDate

		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "EQUITY_STRUCTURE": // 股本结构
		beginDate := condition[0]
		compCode := condition[1]
		exrightDate := condition[2]

		obj := new(domain.EQUITY_STRUCTURE)
		obj.Begindate = beginDate
		obj.Compcode = compCode
		obj.Exrightdate = exrightDate

		has, err := mdb.db.NewSession().Get(obj)
		return has, err
	case "EQUITY_STRUCTURE_CHANGE": //股本变动数据
		beginDate := condition[0]
		compCode := condition[1]
		exrightDate := condition[2]

		obj := new(domain.EQUITY_STRUCTURE_CHANGE)
		obj.Begindate = beginDate
		obj.Compcode = compCode
		obj.Exrightdate = exrightDate

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "HOLDER_CHANGE": // 股东变化情况
		compCode := condition[0]
		endDate := condition[1]

		obj := new(domain.HOLDER_CHANGE)
		obj.Compcode = compCode
		obj.Enddate = endDate

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "TEN_CIRCULATING_SHARES_HOLDER": //十大流通股股东
		compCode := condition[0]
		shholderName := condition[1]
		endDate := condition[2]
		rank := condition[3]

		obj := new(domain.TEN_CIRCULATING_SHARES_HOLDER)
		obj.Compcode = compCode
		obj.Shholdername = shholderName
		obj.Enddate = endDate
		obj.Rank = rank

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "TEN_HOLDER": // 十大股东
		compCode := condition[0]
		shholderName := condition[1]
		endDate := condition[2]
		rank := condition[3]

		obj := new(domain.TEN_HOLDER)
		obj.Compcode = compCode
		obj.Shholdername = shholderName
		obj.Enddate = endDate
		obj.Rank = rank

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "RANK_LIST": //龙虎榜
		symbol := condition[0]
		tradeDate := condition[1]
		chgType := condition[2]
		bizsUnitCode := condition[3]
		transDir := condition[4]

		obj := new(domain.RANK_LIST)
		obj.Symbol = symbol
		obj.Tradedate = tradeDate
		obj.Chgtype = chgType
		obj.Bizsunitcode = bizsUnitCode
		obj.Transdir = transDir

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	case "BLOCK_TRADING": //大宗交易
		symbol := condition[0]
		blockTradeId := condition[1]
		exchange := condition[2]

		obj := new(domain.BLOCK_TRADING)
		obj.Symbol = symbol
		obj.Blocktradeid = blockTradeId
		obj.Exchange = exchange

		has, err := mdb.db.NewSession().Get(obj)
		return has, err

	default:
		return true, nil
	}

	return true, nil
}

//FixBizData 补充相应业务表的数据
func (mdb *db) FixBizData(ctx context.Context, v interface{}) error {
	// 资料部分
	// 大事提醒
	if rows, ok := v.([]*domain.EVENT_REMIND); ok {
		global.LOG.Info("获取相应时间间隔的大事提醒数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.EVENT_REMIND
		for _, r := range rows {
			rankStr := strconv.Itoa(r.Rank)
			has, err := mdb.HasBizData("EVENT_REMIND", r.Compcode, r.Declaredate, r.Eventtitle, rankStr)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断大事提醒数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			eventNums, e := mdb.InsertEventRemind(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充大事提醒数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充大事提醒数据条数:", zap.Int64("nums", eventNums))
		} else {
			global.LOG.Info("补充大事提醒数据条数:", zap.Int64("nums", 0))
		}

		return nil
	}
	// 分红派送
	if rows, ok := v.([]*domain.DIVIDEND); ok {
		global.LOG.Info("获取相应时间间隔的分红派送数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.DIVIDEND
		for _, r := range rows {
			has, err := mdb.HasBizData("DIVIDEND", r.Compcode, r.Exrightdate, r.Bonusyear, r.Dividtype, r.Divitype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断分红派送数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			dividendNums, e := mdb.InsertDividend(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充分红派送数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充分红派送数据条数:", zap.Int64("nums", dividendNums))
		} else {
			global.LOG.Info("补充分红派送数据条数:", zap.Int64("nums", 0))
		}

	}
	// 融资融券
	if rows, ok := v.([]*domain.MARGIN); ok {
		global.LOG.Info("获取相应时间间隔的融资融券数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.MARGIN
		for _, r := range rows {
			has, err := mdb.HasBizData("MARGIN", r.Symbol, r.Tradedate)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断融资融券数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			marginNums, e := mdb.InsertMargin(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充融资融券数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充融资融券数据条数:", zap.Int64("nums", marginNums))
		} else {
			global.LOG.Info("补充融资融券数据条数:", zap.Int64("nums", 0))
		}
	}
	// 盈利预测
	if rows, ok := v.([]*domain.PROFIT_FORECAST); ok {
		global.LOG.Info("获取相应时间间隔的盈利预测数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.PROFIT_FORECAST
		for _, r := range rows {
			has, err := mdb.HasBizData("PROFIT_FORECAST", r.Compcode, r.Symbol, r.Publishdate, r.Exptyear)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断盈利预测数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			pfNums, e := mdb.InsertProfitForecast(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充盈利预测失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充盈利预测条数:", zap.Int64("nums", pfNums))
		} else {
			global.LOG.Info("补充盈利预测条数:", zap.Int64("nums", 0))
		}

	}
	// 股本结构信息
	if rows, ok := v.([]*domain.EQUITY_STRUCTURE); ok {
		global.LOG.Info("获取相应时间间隔的股本结构信息数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.EQUITY_STRUCTURE
		for _, r := range rows {
			has, err := mdb.HasBizData("EQUITY_STRUCTURE", r.Begindate, r.Compcode, r.Exrightdate)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断股本结构信息数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			esNums, e := mdb.InsertEquityStructure(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充股本结构信息失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充股本结构信息数据条数:", zap.Int64("nums", esNums))
		} else {
			global.LOG.Info("补充股本结构信息数据条数:", zap.Int64("nums", 0))
		}
	}
	// 股本变动数据
	if rows, ok := v.([]*domain.EQUITY_STRUCTURE_CHANGE); ok {
		global.LOG.Info("获取相应时间间隔的股本变动数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.EQUITY_STRUCTURE_CHANGE
		for _, r := range rows {
			has, err := mdb.HasBizData("EQUITY_STRUCTURE_CHANGE", r.Begindate, r.Compcode, r.Exrightdate)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断股本变动数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			eschgs, e := mdb.InsertEquityStruChg(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充股本变动数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充股本变动数据条数:", zap.Int64("nums", eschgs))
		} else {
			global.LOG.Info("补充股本变动数据条数:", zap.Int64("nums", 0))
		}
	}
	// 十大流通股股东
	if rows, ok := v.([]*domain.TEN_CIRCULATING_SHARES_HOLDER); ok {
		global.LOG.Info("获取相应时间间隔的十大流通股股东数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.TEN_CIRCULATING_SHARES_HOLDER
		for _, r := range rows {
			has, err := mdb.HasBizData("TEN_CIRCULATING_SHARES_HOLDER", r.Compcode, r.Shholdername, r.Enddate, r.Rank)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断十大流通股股东数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			shNums, e := mdb.InsertTenCirculatingSharesHolder(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充十大流通股股东失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充十大流通股股东数据条数:", zap.Int64("nums", shNums))
		} else {
			global.LOG.Info("补充十大流通股股东数据条数:", zap.Int64("nums", 0))
		}
	}
	// 分红融资
	if rows, ok := v.([]*domain.BONUS_FINANCING); ok {
		global.LOG.Info("获取相应时间间隔的分红融资数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.BONUS_FINANCING
		for _, r := range rows {
			has, err := mdb.HasBizData("BONUS_FINANCING", r.Compcode, r.Bonusyear, r.Dividtype, r.Divitype, r.Exrightdate)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断分红融资数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			bfNums, e := mdb.InsertBonusFinancing(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充分红融资失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充分红融资数据条数:", zap.Int64("nums", bfNums))
		} else {
			global.LOG.Info("补充分红融资数据条数:", zap.Int64("nums", 0))
		}

	}
	// 龙虎榜
	if rows, ok := v.([]*domain.RANK_LIST); ok {
		global.LOG.Info("获取相应时间间隔的龙虎榜数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.RANK_LIST
		for _, r := range rows {
			has, err := mdb.HasBizData("RANK_LIST", r.Symbol, r.Tradedate, r.Chgtype, r.Bizsunitcode, r.Transdir)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断龙虎榜数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			rlNums, e := mdb.InsertRankList(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充龙虎榜失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充龙虎榜数据条数:", zap.Int64("nums", rlNums))
		} else {
			global.LOG.Info("补充龙虎榜数据条数:", zap.Int64("nums", 0))
		}
	}
	// 大宗交易
	if rows, ok := v.([]*domain.BLOCK_TRADING); ok {
		global.LOG.Info("获取相应时间间隔的大宗交易数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.BLOCK_TRADING
		for _, r := range rows {
			has, err := mdb.HasBizData("BLOCK_TRADING", r.Symbol, r.Blocktradeid, r.Exchange)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断大宗交易数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			btNums, err := mdb.InsertBlockTrading(ctx, datas)
			if err != nil {
				global.LOG.Fatal("补充大宗交易失败！", zap.Any("err", err))
				return err
			}
			global.LOG.Info("补充大宗交易数据条数:", zap.Int64("nums", btNums))
		} else {
			global.LOG.Info("补充大宗交易数据条数:", zap.Int64("nums", 0))
		}

	}
	// 公司高管
	if rows, ok := v.([]*domain.COMPANY_EXECUTIVES); ok {
		global.LOG.Info("获取相应时间间隔的公司高管数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.COMPANY_EXECUTIVES
		for _, r := range rows {
			has, err := mdb.HasBizData("COMPANY_EXECUTIVES", r.Compcode, r.Personalcode, r.Actdutyname, r.Begindate)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断公司高管数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			ceNums, err := mdb.InsertCompanyExecutives(ctx, datas)
			if err != nil {
				global.LOG.Fatal("补充公司高管信息失败！", zap.Any("err", err))
				return err
			}
			global.LOG.Info("补充公司高管数据条数:", zap.Int64("nums", ceNums))
		} else {
			global.LOG.Info("补充公司高管数据条数:", zap.Int64("nums", 0))
		}
	}
	// 主要业务
	if rows, ok := v.([]*domain.MAIN_COMPOSITION); ok {
		global.LOG.Info("获取相应时间间隔的公司主要业务数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.MAIN_COMPOSITION
		for _, r := range rows {
			has, err := mdb.HasBizData("MAIN_COMPOSITION", r.Compcode, r.Publishdate, r.Typestyle)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断公司主要业务数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			mcNums, e := mdb.InsertMainComposition(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充公司主要业务数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充公司主要业务数据条数:", zap.Int64("nums", mcNums))
		} else {
			global.LOG.Info("补充公司主要业务数据条数:", zap.Int64("nums", 0))
		}

	}
	// 公司基本情况
	if rows, ok := v.([]*domain.COMPANY_PROFILE); ok {
		global.LOG.Info("获取相应时间间隔的公司基本情况数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.COMPANY_PROFILE

		for _, r := range rows {
			has, err := mdb.HasBizData("COMPANY_PROFILE", r.Compcode, r.Symbol, r.Exchange)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断公司基本情况数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			cpNums, e := mdb.InsertCompanyProfile(ctx, datas)
			if e != nil {
				global.LOG.Fatal("插入公司基本情况数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("新增公司基本情况数据条数:", zap.Int64("nums", cpNums))
		} else {
			global.LOG.Info("新增公司基本情况数据条数:", zap.Int64("nums", 0))
		}

	}
	// 股东变动情况
	if rows, ok := v.([]*domain.HOLDER_CHANGE); ok {
		global.LOG.Info("获取相应时间间隔的股东变动情况数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.HOLDER_CHANGE

		for _, r := range rows {
			has, err := mdb.HasBizData("HOLDER_CHANGE", r.Compcode, r.Enddate)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断股东变动情况是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			hcNums, e := mdb.InsertHolderChange(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充股东变动情况数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充股东变动情况数据条数:", zap.Int64("nums", hcNums))
		} else {
			global.LOG.Info("补充股东变动情况数据条数:", zap.Int64("nums", 0))
		}

	}
	// 十大股东
	if rows, ok := v.([]*domain.TEN_HOLDER); ok {
		global.LOG.Info("获取相应时间间隔的十大股东数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.TEN_HOLDER

		for _, r := range rows {
			has, err := mdb.HasBizData("TEN_HOLDER", r.Compcode, r.Shholdername, r.Enddate, r.Rank)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断股东变动情况是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			thNums, e := mdb.InsertTenHolder(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充十大股东数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充十大股东数据条数:", zap.Int64("nums", thNums))
		} else {
			global.LOG.Info("补充十大股东数据条数:", zap.Int64("nums", 0))
		}

	}
	// 机构评级信息
	if rows, ok := v.([]*domain.RATING); ok {
		global.LOG.Info("获取相应时间间隔的机构评级信息数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.RATING
		for _, r := range rows {
			has, err := mdb.HasBizData("RATING", r.Skcode, r.Reportdate, r.Ratingvalid, r.Analystname)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断龙虎榜数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			ratingCnt, e := mdb.InsertRating(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充机构评级信息失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充机构评级信息数据条数:", zap.Int64("nums", ratingCnt))
		} else {
			global.LOG.Info("补充机构评级信息数据条数:", zap.Int64("nums", 0))
		}

	}
	// 机构评级统计信息
	if rows, ok := v.([]*domain.RATING_COUNT); ok {
		global.LOG.Info("获取相应时间间隔的机构评级统计信息数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.RATING_COUNT
		for _, r := range rows {
			has, err := mdb.HasBizData("RATING_COUNT", r.Symbol, r.Ratingvalid)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断评级统计数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			rcnts, e := mdb.InsertRatingCount(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充机构评级统计数据失败！", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充机构评级统计数据条数:", zap.Int64("nums", rcnts))
		} else {
			global.LOG.Info("补充机构评级统计数据条数:", zap.Int64("nums", 0))
		}

	}
	// 最新指标
	if rows, ok := v.([]*domain.LATEST_INDICATOR); ok {
		global.LOG.Info("获取相应时间间隔的最新指标数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.LATEST_INDICATOR
		for _, r := range rows {
			has, err := mdb.HasBizData("LATEST_INDICATOR", r.Compcode, r.Symbol, r.Exchange, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断最新指标是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			liNums, e := mdb.InsertLatestIndicator(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充最新指标数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充最新指标数据条数:", zap.Int64("nums", liNums))
		} else {
			global.LOG.Info("补充最新指标数据条数:", zap.Int64("nums", 0))
		}
	}
	//财务部分
	// 资产负债
	if rows, ok := v.([]*domain.BALANCE_SHEET); ok {
		global.LOG.Info("获取相应时间间隔的资产负债数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.BALANCE_SHEET

		for _, r := range rows {
			has, err := mdb.HasBizData("BALANCE_SHEET", r.Compcode, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断资产负债数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			bsNums, e := mdb.InsertBalanceSheet(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充财务资产负债数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-资产负债新增数据条数:", zap.Int64("nums", bsNums))
		} else {
			global.LOG.Info("补充财务数据-资产负债新增数据条数:", zap.Int64("nums", 0))
		}

	}
	// 企业利润
	if rows, ok := v.([]*domain.INCOME_STATEMENT); ok {
		global.LOG.Info("获取相应时间间隔的企业利润数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.INCOME_STATEMENT

		for _, r := range rows {
			has, err := mdb.HasBizData("INCOME_STATEMENT", r.Compcode, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断企业利润数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			incomeNums, e := mdb.InsertIncomeStatement(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充企业利润数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-企业利润新增数据条数:", zap.Int64("nums", incomeNums))
		} else {
			global.LOG.Info("补充财务数据-企业利润新增数据条数:", zap.Int64("nums", 0))
		}

	}
	// 现金流量
	if rows, ok := v.([]*domain.CASH_FLOW); ok {
		global.LOG.Info("获取相应时间间隔的现金流量数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.CASH_FLOW

		for _, r := range rows {
			has, err := mdb.HasBizData("CASH_FLOW", r.Compcode, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断现金流数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			cashFlowNums, e := mdb.InsertCashFlow(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充企业现金流数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-企业现金流新增数据条数:", zap.Int64("nums", cashFlowNums))
		} else {
			global.LOG.Info("补充财务数据-企业现金流新增数据条数:", zap.Int64("nums", 0))
		}

	}
	// 企业利润单季度
	if rows, ok := v.([]*domain.INCOME_STATEMENT_SQ); ok {
		global.LOG.Info("获取相应时间间隔的企业利润单季度数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.INCOME_STATEMENT_SQ

		for _, r := range rows {
			has, err := mdb.HasBizData("INCOME_STATEMENT_SQ")
			if err != nil {
				global.LOG.Error("根据 业务主键 判断企业利润单季度数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			incomeSqNums, e := mdb.InsertIncomeStatementSq(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充企业利润-单季度数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-企业利润-单季度新增数据条数:", zap.Int64("nums", incomeSqNums))
		} else {
			global.LOG.Info("补充财务数据-企业利润-单季度新增数据条数:", zap.Int64("nums", 0))
		}

	}
	// 现金流 单季度
	if rows, ok := v.([]*domain.CASH_FLOW_SQ); ok {
		global.LOG.Info("获取相应时间间隔的现金流-单季度数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.CASH_FLOW_SQ

		for _, r := range rows {
			has, err := mdb.HasBizData("CASH_FLOW_SQ", r.Compcode, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断现金流-单季度数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			cashFlowSqNums, e := mdb.InsertCashFlowSq(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充企业现金流-单季度数据失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-企业现金流-单季度新增数据条数:", zap.Int64("nums", cashFlowSqNums))
		} else {
			global.LOG.Info("补充财务数据-企业现金流-单季度新增数据条数:", zap.Int64("nums", 0))
		}

	}
	// 主要指标
	if rows, ok := v.([]*domain.KEY_INDICATOR); ok {
		global.LOG.Info("获取相应时间间隔的主要指标数据量：", zap.Int("nums", len(rows)))

		var datas []*domain.KEY_INDICATOR
		for _, r := range rows {
			has, err := mdb.HasBizData("KEY_INDICATOR", r.Compcode, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断主要指标数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			kiNums, e := mdb.InsertKeyIndicator(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充财务主要指标失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-主要指标共新增数据条数:", zap.Int64("nums", kiNums))
		} else {
			global.LOG.Info("补充财务数据-主要指标共新增数据条数:", zap.Int64("nums", 0))
		}

	}

	// 主要指标-单季度
	if rows, ok := v.([]*domain.KEY_INDICATOR_SQ); ok {
		global.LOG.Info("获取相应时间间隔的主要指标-单季度数据量：", zap.Int("nums", len(rows)))
		var datas []*domain.KEY_INDICATOR_SQ
		for _, r := range rows {
			has, err := mdb.HasBizData("KEY_INDICATOR_SQ", r.Compcode, r.Reportyear, r.Reportdatetype)
			if err != nil {
				global.LOG.Error("根据 业务主键 判断主要指标-单季度数据是否存在出错:", zap.Any("err", err))
				return err
			}

			//过滤掉已经存在的数据
			if !has {
				datas = append(datas, r)
			}
		}

		if len(datas) > 0 {
			kisqNums, e := mdb.InsertKeyIndicatorSq(ctx, datas)
			if e != nil {
				global.LOG.Fatal("补充财务主要指标-单季度失败:", zap.Any("err", e))
				return e
			}
			global.LOG.Info("补充财务数据-主要指标-单季度共新增数据条数:", zap.Int64("nums", kisqNums))
		} else {
			global.LOG.Info("补充财务数据-主要指标-单季度共新增数据条数:", zap.Int64("nums", 0))
		}
	}

	return nil
}
